package myservlet;

import java.io.BufferedReader;
import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;

public class take_json {
	Gson g=new Gson();
	
	//解析客户端发送过来的json字符s串，返回结果
			public String json(HttpServletRequest request) {
				JSONObject jobj=JSONObject.parseObject(ReadAsChars(request));
				//分析数据
				String nowdataclass;
				try {//获取dataclass类型
					nowdataclass=jobj.getString(json_enum_dataclass.dataclass.toString());
				}catch(JSONException e){
					return result_null;
				}
				//处理dataclass
				if(nowdataclass.equals(json_enum_dataclass.database_list.toString())) {
					return fun_database_list(nowdataclass);
				}else if(nowdataclass.equals(json_enum_dataclass.paper_list.toString())){
					return fun_paper_list(nowdataclass);
				}else if(nowdataclass.equals(json_enum_dataclass.paper.toString())){
					return fun_paper_info(nowdataclass,jobj);
				}else if(nowdataclass.equals(json_enum_dataclass.paper_item.toString())){
					return fun_paper(nowdataclass,jobj);
				}else if(nowdataclass.equals(json_enum_dataclass.errors_list.toString())){
					return fun_errors_list("test");
				}else if(nowdataclass.equals(json_enum_dataclass.book_list.toString())) {
					return fun_book_list();
				}else if(nowdataclass.equals(json_enum_dataclass.book.toString())) {
					return fun_book(jobj);
				}else if(nowdataclass.equals(json_enum_dataclass.save_book.toString())) {
					return fun_book(jobj);
				}else if(nowdataclass.equals(json_enum_dataclass.test.toString())) {
					//return fun_test();
				}
				return result_no;
				
			}
			
	//将HttpServletRequest的内容转换为字符串
		public static String ReadAsChars(HttpServletRequest request)
	    {
	 
	        BufferedReader br = null;
	        StringBuilder sb = new StringBuilder("");
	        try
	        {
	            br = request.getReader();
	            String str;
	            while ((str = br.readLine()) != null)
	            {
	                sb.append(str);
	            }
	            br.close();
	        }
	        catch (IOException e)
	        {
	            e.printStackTrace();
	        }
	        finally
	        {
	            if (null != br)
	            {
	                try
	                {
	                    br.close();
	                }
	                catch (IOException e)
	                {
	                    e.printStackTrace();
	                }
	            }
	        }
	        return sb.toString();
	    }
		
		static final String result_true="{\"result\":\"true\"}", result_false="{\"result\":\"false\"}",result_null="{\"result\":\"null\"}",result_no="{\"result\":\"no\"}";
		static final String class_var="dataclass";
		static final String class_var_login="login",class_var_register="register",class_var_question_list="question_list",
				class_var_question="question",class_var_change_username="change_username",class_var_change_password="change_password";
		//为字符串json结构添加dataclass属性
		public String result_dataclass(json_enum_dataclass dataclass,JSONObject jsonobj) {
			try {
				jsonobj.put(json_enum_dataclass.dataclass.toString(),dataclass.toString());
				return jsonobj.toString();
			}catch (JSONException  e){
				return null;
			}
		}
		//
		String [] booklist= {"CSMA/CD（Carrier Sense Multiple",
				"初级会计-初级会计实务",
				"初级会计-经济法基础",
				"计算机二级C语言",
				"曼彻斯特编码",
				"DHCP客户端"
				};
		
		String [] timelist= {
				"13:23 带有冲突检测的载波侦听",
				"14:13 基本职能:核算与监督",
				"15:45 法律关系的要素",
				"17:32【考点1】C程序",
				"18:52 差分曼彻斯特编码",
				"19:32 启动时会向网络发出一个" 
		};
		
		//发送笔记详细信息
			String [] booktextlist= {"CSMA/CD（Carrier Sense Multiple Access/collision detection，带有冲突检测的载波侦听多路存取）是IEEE 802.3使用的一种媒体访问控制方法。从逻辑上可以划分为两大部分：数据链路层的媒体访问控制子层（MAC）和物理层。它严格对应于ISO开放系统互连模式的最低两层。LLC子层和MAC子层在一起完成OSI模式的数据链路层的功能。\r\n"
					+ "\r\n"
					+ "CSMA/CD的基本原理是：所有节点都共享网络传输信道，节点在发送数据之前，首先检测信道是否空闲，如果信道空闲则发送，否则就等待；在发送出信息后，再对冲突进行检测，当发现冲突时，则取消发送。\r\n"
					+ "\r\n"
					+ "CSMA/CD控制方式的优点是：\r\n"
					+ "原理比较简单，技术上易实现，网络中各工作站处于平等地位 ，不需集中控制，不提供优先级控制。但在网络负载增大时，发送时间增长，发送效率急剧下降。",
					
					
					"初级会计-初级会计实务\r\n"
					+ "基本职能:核算与监督\r\n"
					+ "拓展职能:预测经济前景、参与经济决策、评价经营业绩\r\n"
					+ "会计基础:权责发生制(认账不认钱)、收付实现制\r\n"
					+ "会计信息质量要求:可靠性、相关性、可理解性、可比性、实质重于形式、重要性、谨慎性、及时性\r\n"
					+ "会计等式:资产＝负债＋所有者权益",
					
					
					
					"初级会计-经济法基础\r\n"
					+ "法律关系的要素\r\n"
					+ "1.法律关系是由法律关系的主体、法律关系的内容和法律关系的客体三个要素构成的。缺少其中任何一个要素，都不能构成法律关系。\r\n"
					+ "2.法律关系的主体包括：自然人、组织（法人和非法人组织）、国家。\r\n"
					+ "【注意 1】营利法人包括有限责任公司、股份有限公司和其他企业法人等。\r\n"
					+ "【注意 2】非营利法人包括事业单位、社会团体、基金会、社会服务机构等。\r\n"
					+ "【注意 3】机关法人、农村集体经济组织法人、城镇农村的合作经济组织法人、基层群众性自治组织法人为特别法人。\r\n"
					+ "【注意 4】非法人组织包括个人独资企业、合伙企业、不具有法人资格的专业服务机构等。\r\n"
					+ "3.法律关系的内容是指法律关系主体所享有的权利和承担的义务。\r\n"
					+ "4.法律关系客体是指法律关系主体的权利和义务所指向的对象。一般认为，法律关系的客体主要包括物、人身人格、精神产品和行为四大类。",
					
					
					
					"计算机二级C语言\r\n"
					+ "【考点1】C程序\r\n"
					+ "用C语言编写的程序称为C语言源程序，源程序文件的后缀名为“.c”。源程序经编译后生成后缀名为“.obj”的目标文件，再把目标文件与各种库函数连接起来，生成“.exe”可执行文件。C语言有三种基本结构：顺序结构、选择结构、循环结构。\r\n"
					+ "【考点2】main函数\r\n"
					+ "又称主函数，是C程序的入口。main后面跟一对小括号和一对花括号，花括号括起来的部分称为main函数的函数体。一个C程序从main函数开始执行，到main函数体执行完结束，而不论main函数在整个程序中的位置如何。每一个程序有且仅有一个main函数，其他函数都是为main函数服务的。\r\n"
					+ "【考点3】存储形式\r\n"
					+ "计算机在电脑中保存数据是采用二进制形式，由0或1构成的二进制称为位(bit)，八个位构成一个字节(Byte)，1个Byte=8个bit。二进制、八进制、十六进制转化为十进制采用乘法，十进制转化为二进制、八进制、十六进制采用除法。数据的存放位置就是他的地址。"
					};
		
		//处理database_list请求
		public String fun_database_list(String nowdataclass) {
			jstruct_database_list jsdl=new jstruct_database_list();
			try {
				String datalist[]= {"网络工程师","英语四级",
						"英语六级",
						"计算机软考",
						"计算机等级考试二级",
						"计算机等级考试三级",
						"计算机等级考试四级",
						"Linux认证",
						"红帽认证工程师（RHCE）",
						"红帽认证架构师（RHCA）"
						};
				jsdl.dataclass=nowdataclass;
				jsdl.listname=datalist;
				
				jsdl.length=datalist.length;
				jsdl.error=false;
			} catch (JSONException e) {
				//e.printStackTrace();
				jsdl.error=true;
			}
			return g.toJson(jsdl);
		}
		
		String paperlist[]= {
				"网络体系结构",
				"计算机硬件知识",
				"计算机软件知识",
				"Windows管理",
				"Windows配置",
				"Linux管理",
				"Linux命令",
				"Linux配置",
				  "交换基础",
				  "交换机配置",
				  "路由基础",
				  "路由配置",
				  "防火墙配置",
				  "VPN配置"
				};
		//出题试题列表
		public String  fun_paper_list(String dataclass) {

			Gson g=new Gson();
			jstruct_paper_list jrb=new jstruct_paper_list();
			try {
				jrb.dataclass=dataclass;
				jrb.listname= paperlist;
				jrb.length=paperlist.length;
				jrb.error=false;
			}catch(Exception e) {
				jrb.error=true;
			}
			return g.toJson(jrb);
		}
		

		String [] cho_q= {
				"已知一台计算机A的IP地址为：132.121.100.1，子网掩码为255.255.0.0，则这台计算器属于（ ）。",
				"网络设计过程包括逻辑网络设计和物理网络设计两个阶段，各个阶段都要产生相应的文档。下面的选项中，属于逻辑网络设计文档的是（ ）。",
				
				"asd"
		};
		
		String [] errors_list11= {
				"为了限制路由信息传播的范围，",
				"在Linux中，目录“/proc”主要",
				"高压输电网中的铁架与导线",
				"RMON和SNMP的主要区别是",
				"SNMP采用UDP提供的数据报服务",
				"在网络管理中要防止各种安全",
				"采用CSMA/CD协议的基带总线，",
				"IEEE 802.11采用了CSMA/CA协",
				"在IEEE 802.11标准中使用了扩",
		};
		String [] errors_timelist1= {
				"13:46 OSPF协议把网络划分成4种区",
				"13:50 用于存放进程和系统信息",
				"13:51 之间必须用绝缘材料连",
				"14:32 RMON提供了整个子网的管理信",
				"14:32 UDP实现网络管理的效率较高",
				"14:32 威胁。在SNMP中无法预防",
				"16:13 其段长为1000m，中间没有中",
				"16:13 议，下面关于这个协议的描述",
				"18:25 频通信技术，下面选项中有关"
				
		};
		
		//选择题：
		String [][] cho_a= {
				{" A．A类网"," B．B类网"," C．C类网"," D．类网"},
				{" A. 网络IP地址分配方案",
			" B· 设备列表清单",
			" C. 集中访谈的信息资料",
			" D. 网络内部的通信流量分布"},
							{"A．铝合金","B．干木头","C．橡胶","D．陶瓷"}};
		int [] sel= {1,1,3};
		//填空题
		String [][] coma= {{
					"采用CSMA/CD协议的基带总线，其段长为1000m，中间没有中继器，数据速率为10Mb/s，信号传播速度为200m/µs，为了保证在发送期间能够检测到冲突，则该网络上的最小帧长应为____比特",
			"150 "},
							{"1+1=____","2"},
							{"2+2=____","4"},
							{"3+3=____","6"}};
		
		//处理试题信息
		public String  fun_paper_info(String dataclass,JSONObject jobj) {
			jstruct_paper_info jrb=new jstruct_paper_info();
			//解析发送过来的数据
			jstruct_get_paper get1=g.fromJson(jobj.toJSONString(), jstruct_get_paper.class);
			try {
				jrb.dataclass=dataclass;
				jrb.papername=get1.papername;
				jrb.choice_qu_num= 3;
				jrb.completion_qu_num=20;
				jrb.error=false;
			}catch(Exception e) {
				jrb.error=true;
			}
			return g.toJson(jrb);
		}
		//处理试题
		public String fun_paper(String dataclass,JSONObject jobj) {
			jstruct_paper_item jspi=new jstruct_paper_item();
			jstruct_paper_item_send get1=g.fromJson(jobj.toJSONString(), jstruct_paper_item_send.class);
			try {
				if(get1.item<3) {
					jspi.text=cho_q[get1.item];
					jspi.answer="";
					jspi.fanswer=cho_a[get1.item];
					jspi.type=jenum_paper_item_type.cho.toString();
					jspi.cho=sel[get1.item];//选择题正确答案
				}else {
					jspi.text=coma[get1.item-3][0];
					jspi.answer=coma[get1.item-3][1];
					jspi.type=jenum_paper_item_type.com.toString();
				}
				jspi.dataclass=dataclass;
				jspi.item=get1.item;
				jspi.error=false;
			}catch(Exception e) {
				jspi.error=true;
			}
			return g.toJson(jspi);
		}
		//处理错题集列表
		
		int [] items= {0,1,2};
		public String fun_errors_list(String username) {
			jstruct_errors_list jsel=new jstruct_errors_list();
			try {
				jsel.dataclass=json_enum_dataclass.errors_list.toString();
				jsel.listname=errors_list11;
				jsel.timelist=errors_timelist1;
				jsel.items=items;
				jsel.length=cho_q.length;
				jsel.error=false;
			}catch(Exception e){
				jsel.error=true;
			}
			return g.toJson(jsel);
		}
		
		//笔记部分
		//发送笔记列表

		public String fun_book_list() {
			jstruct_book_list jsbl=new jstruct_book_list();
			try {
				jsbl.dataclass=json_enum_dataclass.book_list.toString();
				jsbl.listname=booklist;
				jsbl.timelist=timelist;
				jsbl.length=booklist.length;
				jsbl.error=false;
			}catch(Exception e){
				jsbl.error=true;
			}
			return g.toJson(jsbl);
		}
		
		public String fun_book(JSONObject jobj) {
			jstruct_book_send j=g.fromJson(jobj.toString(), jstruct_book_send.class);
			jstruct_book_receive send=new jstruct_book_receive();
			send.dataclass=json_enum_dataclass.save_book.toString();
			send.username="test";
			send.text=booktextlist[j.index];
			send.error=false;
			return g.toJson(send);
		}
		//保存编辑
		public String fun_book_edit(JSONObject jobj) {
			jstruct_book_edit_save j=g.fromJson(jobj.toString(), jstruct_book_edit_save.class);
			booklist=insertElement(booklist,"hello",0);
			booktextlist=insertElement(booktextlist,j.text,0);
			jstruct_book_edit_save_ret send=new jstruct_book_edit_save_ret();
			send.dataclass=json_enum_dataclass.save_book.toString();
			send.result=true;
			send.error=false;
			return g.toJson(send);
		}
		
		private static String[] insertElement(String original[],String element,int index){
			
			int length=original.length;
			
			String destination[]=new String[length+1];
			
			System.arraycopy(original, 0, destination, 0, index);
			
			destination[index]=element;
			
			System.arraycopy(original, index, destination, index+1, length-index);
			
			return destination;
		}
		
		public String fun_test() {
			//jstruct js=new jstruct();
			//js.client.login.username="123";
			//return g.toJson(js);
			return result_null;
		}
}
